home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Linux / SLAX 6.0.8 / slax-6.0.8.iso / slax / base / 006-devel.lzm / usr / share / aclocal / lib-link.m4 < prev    next >
Encoding:
M4 Source File  |  2008-03-13  |  29.0 KB  |  710 lines
  1. # lib-link.m4 serial 13 (gettext-0.17)
  2. dnl Copyright (C) 2001-2007 Free Software Foundation, Inc.
  3. dnl This file is free software; the Free Software Foundation
  4. dnl gives unlimited permission to copy and/or distribute it,
  5. dnl with or without modifications, as long as this notice is preserved.
  6.  
  7. dnl From Bruno Haible.
  8.  
  9. AC_PREREQ(2.54)
  10.  
  11. dnl AC_LIB_LINKFLAGS(name [, dependencies]) searches for libname and
  12. dnl the libraries corresponding to explicit and implicit dependencies.
  13. dnl Sets and AC_SUBSTs the LIB${NAME} and LTLIB${NAME} variables and
  14. dnl augments the CPPFLAGS variable.
  15. dnl Sets and AC_SUBSTs the LIB${NAME}_PREFIX variable to nonempty if libname
  16. dnl was found in ${LIB${NAME}_PREFIX}/$acl_libdirstem.
  17. AC_DEFUN([AC_LIB_LINKFLAGS],
  18. [
  19.   AC_REQUIRE([AC_LIB_PREPARE_PREFIX])
  20.   AC_REQUIRE([AC_LIB_RPATH])
  21.   define([Name],[translit([$1],[./-], [___])])
  22.   define([NAME],[translit([$1],[abcdefghijklmnopqrstuvwxyz./-],
  23.                                [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])])
  24.   AC_CACHE_CHECK([how to link with lib[]$1], [ac_cv_lib[]Name[]_libs], [
  25.     AC_LIB_LINKFLAGS_BODY([$1], [$2])
  26.     ac_cv_lib[]Name[]_libs="$LIB[]NAME"
  27.     ac_cv_lib[]Name[]_ltlibs="$LTLIB[]NAME"
  28.     ac_cv_lib[]Name[]_cppflags="$INC[]NAME"
  29.     ac_cv_lib[]Name[]_prefix="$LIB[]NAME[]_PREFIX"
  30.   ])
  31.   LIB[]NAME="$ac_cv_lib[]Name[]_libs"
  32.   LTLIB[]NAME="$ac_cv_lib[]Name[]_ltlibs"
  33.   INC[]NAME="$ac_cv_lib[]Name[]_cppflags"
  34.   LIB[]NAME[]_PREFIX="$ac_cv_lib[]Name[]_prefix"
  35.   AC_LIB_APPENDTOVAR([CPPFLAGS], [$INC]NAME)
  36.   AC_SUBST([LIB]NAME)
  37.   AC_SUBST([LTLIB]NAME)
  38.   AC_SUBST([LIB]NAME[_PREFIX])
  39.   dnl Also set HAVE_LIB[]NAME so that AC_LIB_HAVE_LINKFLAGS can reuse the
  40.   dnl results of this search when this library appears as a dependency.
  41.   HAVE_LIB[]NAME=yes
  42.   undefine([Name])
  43.   undefine([NAME])
  44. ])
  45.  
  46. dnl AC_LIB_HAVE_LINKFLAGS(name, dependencies, includes, testcode)
  47. dnl searches for libname and the libraries corresponding to explicit and
  48. dnl implicit dependencies, together with the specified include files and
  49. dnl the ability to compile and link the specified testcode. If found, it
  50. dnl sets and AC_SUBSTs HAVE_LIB${NAME}=yes and the LIB${NAME} and
  51. dnl LTLIB${NAME} variables and augments the CPPFLAGS variable, and
  52. dnl #defines HAVE_LIB${NAME} to 1. Otherwise, it sets and AC_SUBSTs
  53. dnl HAVE_LIB${NAME}=no and LIB${NAME} and LTLIB${NAME} to empty.
  54. dnl Sets and AC_SUBSTs the LIB${NAME}_PREFIX variable to nonempty if libname
  55. dnl was found in ${LIB${NAME}_PREFIX}/$acl_libdirstem.
  56. AC_DEFUN([AC_LIB_HAVE_LINKFLAGS],
  57. [
  58.   AC_REQUIRE([AC_LIB_PREPARE_PREFIX])
  59.   AC_REQUIRE([AC_LIB_RPATH])
  60.   define([Name],[translit([$1],[./-], [___])])
  61.   define([NAME],[translit([$1],[abcdefghijklmnopqrstuvwxyz./-],
  62.                                [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])])
  63.  
  64.   dnl Search for lib[]Name and define LIB[]NAME, LTLIB[]NAME and INC[]NAME
  65.   dnl accordingly.
  66.   AC_LIB_LINKFLAGS_BODY([$1], [$2])
  67.  
  68.   dnl Add $INC[]NAME to CPPFLAGS before performing the following checks,
  69.   dnl because if the user has installed lib[]Name and not disabled its use
  70.   dnl via --without-lib[]Name-prefix, he wants to use it.
  71.   ac_save_CPPFLAGS="$CPPFLAGS"
  72.   AC_LIB_APPENDTOVAR([CPPFLAGS], [$INC]NAME)
  73.  
  74.   AC_CACHE_CHECK([for lib[]$1], [ac_cv_lib[]Name], [
  75.     ac_save_LIBS="$LIBS"
  76.     LIBS="$LIBS $LIB[]NAME"
  77.     AC_TRY_LINK([$3], [$4], [ac_cv_lib[]Name=yes], [ac_cv_lib[]Name=no])
  78.     LIBS="$ac_save_LIBS"
  79.   ])
  80.   if test "$ac_cv_lib[]Name" = yes; then
  81.     HAVE_LIB[]NAME=yes
  82.     AC_DEFINE([HAVE_LIB]NAME, 1, [Define if you have the $1 library.])
  83.     AC_MSG_CHECKING([how to link with lib[]$1])
  84.     AC_MSG_RESULT([$LIB[]NAME])
  85.   else
  86.     HAVE_LIB[]NAME=no
  87.     dnl If $LIB[]NAME didn't lead to a usable library, we don't need
  88.     dnl $INC[]NAME either.
  89.     CPPFLAGS="$ac_save_CPPFLAGS"
  90.     LIB[]NAME=
  91.     LTLIB[]NAME=
  92.     LIB[]NAME[]_PREFIX=
  93.   fi
  94.   AC_SUBST([HAVE_LIB]NAME)
  95.   AC_SUBST([LIB]NAME)
  96.   AC_SUBST([LTLIB]NAME)
  97.   AC_SUBST([LIB]NAME[_PREFIX])
  98.   undefine([Name])
  99.   undefine([NAME])
  100. ])
  101.  
  102. dnl Determine the platform dependent parameters needed to use rpath:
  103. dnl   acl_libext,
  104. dnl   acl_shlibext,
  105. dnl   acl_hardcode_libdir_flag_spec,
  106. dnl   acl_hardcode_libdir_separator,
  107. dnl   acl_hardcode_direct,
  108. dnl   acl_hardcode_minus_L.
  109. AC_DEFUN([AC_LIB_RPATH],
  110. [
  111.   dnl Tell automake >= 1.10 to complain if config.rpath is missing.
  112.   m4_ifdef([AC_REQUIRE_AUX_FILE], [AC_REQUIRE_AUX_FILE([config.rpath])])
  113.   AC_REQUIRE([AC_PROG_CC])                dnl we use $CC, $GCC, $LDFLAGS
  114.   AC_REQUIRE([AC_LIB_PROG_LD])            dnl we use $LD, $with_gnu_ld
  115.   AC_REQUIRE([AC_CANONICAL_HOST])         dnl we use $host
  116.   AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT]) dnl we use $ac_aux_dir
  117.   AC_CACHE_CHECK([for shared library run path origin], acl_cv_rpath, [
  118.     CC="$CC" GCC="$GCC" LDFLAGS="$LDFLAGS" LD="$LD" with_gnu_ld="$with_gnu_ld" \
  119.     ${CONFIG_SHELL-/bin/sh} "$ac_aux_dir/config.rpath" "$host" > conftest.sh
  120.     . ./conftest.sh
  121.     rm -f ./conftest.sh
  122.     acl_cv_rpath=done
  123.   ])
  124.   wl="$acl_cv_wl"
  125.   acl_libext="$acl_cv_libext"
  126.   acl_shlibext="$acl_cv_shlibext"
  127.   acl_libname_spec="$acl_cv_libname_spec"
  128.   acl_library_names_spec="$acl_cv_library_names_spec"
  129.   acl_hardcode_libdir_flag_spec="$acl_cv_hardcode_libdir_flag_spec"
  130.   acl_hardcode_libdir_separator="$acl_cv_hardcode_libdir_separator"
  131.   acl_hardcode_direct="$acl_cv_hardcode_direct"
  132.   acl_hardcode_minus_L="$acl_cv_hardcode_minus_L"
  133.   dnl Determine whether the user wants rpath handling at all.
  134.   AC_ARG_ENABLE(rpath,
  135.     [  --disable-rpath         do not hardcode runtime library paths],
  136.     :, enable_rpath=yes)
  137. ])
  138.  
  139. dnl AC_LIB_LINKFLAGS_BODY(name [, dependencies]) searches for libname and
  140. dnl the libraries corresponding to explicit and implicit dependencies.
  141. dnl Sets the LIB${NAME}, LTLIB${NAME} and INC${NAME} variables.
  142. dnl Also, sets the LIB${NAME}_PREFIX variable to nonempty if libname was found
  143. dnl in ${LIB${NAME}_PREFIX}/$acl_libdirstem.
  144. AC_DEFUN([AC_LIB_LINKFLAGS_BODY],
  145. [
  146.   AC_REQUIRE([AC_LIB_PREPARE_MULTILIB])
  147.   define([NAME],[translit([$1],[abcdefghijklmnopqrstuvwxyz./-],
  148.                                [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])])
  149.   dnl Autoconf >= 2.61 supports dots in --with options.
  150.   define([N_A_M_E],[m4_if(m4_version_compare(m4_defn([m4_PACKAGE_VERSION]),[2.61]),[-1],[translit([$1],[.],[_])],[$1])])
  151.   dnl By default, look in $includedir and $libdir.
  152.   use_additional=yes
  153.   AC_LIB_WITH_FINAL_PREFIX([
  154.     eval additional_includedir=\"$includedir\"
  155.     eval additional_libdir=\"$libdir\"
  156.   ])
  157.   AC_LIB_ARG_WITH([lib]N_A_M_E[-prefix],
  158. [  --with-lib]N_A_M_E[-prefix[=DIR]  search for lib$1 in DIR/include and DIR/lib
  159.   --without-lib]N_A_M_E[-prefix     don't search for lib$1 in includedir and libdir],
  160. [
  161.     if test "X$withval" = "Xno"; then
  162.       use_additional=no
  163.     else
  164.       if test "X$withval" = "X"; then
  165.         AC_LIB_WITH_FINAL_PREFIX([
  166.           eval additional_includedir=\"$includedir\"
  167.           eval additional_libdir=\"$libdir\"
  168.         ])
  169.       else
  170.         additional_includedir="$withval/include"
  171.         additional_libdir="$withval/$acl_libdirstem"
  172.       fi
  173.     fi
  174. ])
  175.   dnl Search the library and its dependencies in $additional_libdir and
  176.   dnl $LDFLAGS. Using breadth-first-seach.
  177.   LIB[]NAME=
  178.   LTLIB[]NAME=
  179.   INC[]NAME=
  180.   LIB[]NAME[]_PREFIX=
  181.   rpathdirs=
  182.   ltrpathdirs=
  183.   names_already_handled=
  184.   names_next_round='$1 $2'
  185.   while test -n "$names_next_round"; do
  186.     names_this_round="$names_next_round"
  187.     names_next_round=
  188.     for name in $names_this_round; do
  189.       already_handled=
  190.       for n in $names_already_handled; do
  191.         if test "$n" = "$name"; then
  192.           already_handled=yes
  193.           break
  194.         fi
  195.       done
  196.       if test -z "$already_handled"; then
  197.         names_already_handled="$names_already_handled $name"
  198.         dnl See if it was already located by an earlier AC_LIB_LINKFLAGS
  199.         dnl or AC_LIB_HAVE_LINKFLAGS call.
  200.         uppername=`echo "$name" | sed -e 'y|abcdefghijklmnopqrstuvwxyz./-|ABCDEFGHIJKLMNOPQRSTUVWXYZ___|'`
  201.         eval value=\"\$HAVE_LIB$uppername\"
  202.         if test -n "$value"; then
  203.           if test "$value" = yes; then
  204.             eval value=\"\$LIB$uppername\"
  205.             test -z "$value" || LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$value"
  206.             eval value=\"\$LTLIB$uppername\"
  207.             test -z "$value" || LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }$value"
  208.           else
  209.             dnl An earlier call to AC_LIB_HAVE_LINKFLAGS has determined
  210.             dnl that this library doesn't exist. So just drop it.
  211.             :
  212.           fi
  213.         else
  214.           dnl Search the library lib$name in $additional_libdir and $LDFLAGS
  215.           dnl and the already constructed $LIBNAME/$LTLIBNAME.
  216.           found_dir=
  217.           found_la=
  218.           found_so=
  219.           found_a=
  220.           eval libname=\"$acl_libname_spec\"    # typically: libname=lib$name
  221.           if test -n "$acl_shlibext"; then
  222.             shrext=".$acl_shlibext"             # typically: shrext=.so
  223.           else
  224.             shrext=
  225.           fi
  226.           if test $use_additional = yes; then
  227.             dir="$additional_libdir"
  228.             dnl The same code as in the loop below:
  229.             dnl First look for a shared library.
  230.             if test -n "$acl_shlibext"; then
  231.               if test -f "$dir/$libname$shrext"; then
  232.                 found_dir="$dir"
  233.                 found_so="$dir/$libname$shrext"
  234.               else
  235.                 if test "$acl_library_names_spec" = '$libname$shrext$versuffix'; then
  236.                   ver=`(cd "$dir" && \
  237.                         for f in "$libname$shrext".*; do echo "$f"; done \
  238.                         | sed -e "s,^$libname$shrext\\\\.,," \
  239.                         | sort -t '.' -n -r -k1,1 -k2,2 -k3,3 -k4,4 -k5,5 \
  240.                         | sed 1q ) 2>/dev/null`
  241.                   if test -n "$ver" && test -f "$dir/$libname$shrext.$ver"; then
  242.                     found_dir="$dir"
  243.                     found_so="$dir/$libname$shrext.$ver"
  244.                   fi
  245.                 else
  246.                   eval library_names=\"$acl_library_names_spec\"
  247.                   for f in $library_names; do
  248.                     if test -f "$dir/$f"; then
  249.                       found_dir="$dir"
  250.                       found_so="$dir/$f"
  251.                       break
  252.                     fi
  253.                   done
  254.                 fi
  255.               fi
  256.             fi
  257.             dnl Then look for a static library.
  258.             if test "X$found_dir" = "X"; then
  259.               if test -f "$dir/$libname.$acl_libext"; then
  260.                 found_dir="$dir"
  261.                 found_a="$dir/$libname.$acl_libext"
  262.               fi
  263.             fi
  264.             if test "X$found_dir" != "X"; then
  265.               if test -f "$dir/$libname.la"; then
  266.                 found_la="$dir/$libname.la"
  267.               fi
  268.             fi
  269.           fi
  270.           if test "X$found_dir" = "X"; then
  271.             for x in $LDFLAGS $LTLIB[]NAME; do
  272.               AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])
  273.               case "$x" in
  274.                 -L*)
  275.                   dir=`echo "X$x" | sed -e 's/^X-L//'`
  276.                   dnl First look for a shared library.
  277.                   if test -n "$acl_shlibext"; then
  278.                     if test -f "$dir/$libname$shrext"; then
  279.                       found_dir="$dir"
  280.                       found_so="$dir/$libname$shrext"
  281.                     else
  282.                       if test "$acl_library_names_spec" = '$libname$shrext$versuffix'; then
  283.                         ver=`(cd "$dir" && \
  284.                               for f in "$libname$shrext".*; do echo "$f"; done \
  285.                               | sed -e "s,^$libname$shrext\\\\.,," \
  286.                               | sort -t '.' -n -r -k1,1 -k2,2 -k3,3 -k4,4 -k5,5 \
  287.                               | sed 1q ) 2>/dev/null`
  288.                         if test -n "$ver" && test -f "$dir/$libname$shrext.$ver"; then
  289.                           found_dir="$dir"
  290.                           found_so="$dir/$libname$shrext.$ver"
  291.                         fi
  292.                       else
  293.                         eval library_names=\"$acl_library_names_spec\"
  294.                         for f in $library_names; do
  295.                           if test -f "$dir/$f"; then
  296.                             found_dir="$dir"
  297.                             found_so="$dir/$f"
  298.                             break
  299.                           fi
  300.                         done
  301.                       fi
  302.                     fi
  303.                   fi
  304.                   dnl Then look for a static library.
  305.                   if test "X$found_dir" = "X"; then
  306.                     if test -f "$dir/$libname.$acl_libext"; then
  307.                       found_dir="$dir"
  308.                       found_a="$dir/$libname.$acl_libext"
  309.                     fi
  310.                   fi
  311.                   if test "X$found_dir" != "X"; then
  312.                     if test -f "$dir/$libname.la"; then
  313.                       found_la="$dir/$libname.la"
  314.                     fi
  315.                   fi
  316.                   ;;
  317.               esac
  318.               if test "X$found_dir" != "X"; then
  319.                 break
  320.               fi
  321.             done
  322.           fi
  323.           if test "X$found_dir" != "X"; then
  324.             dnl Found the library.
  325.             LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-L$found_dir -l$name"
  326.             if test "X$found_so" != "X"; then
  327.               dnl Linking with a shared library. We attempt to hardcode its
  328.               dnl directory into the executable's runpath, unless it's the
  329.               dnl standard /usr/lib.
  330.               if test "$enable_rpath" = no || test "X$found_dir" = "X/usr/$acl_libdirstem"; then
  331.                 dnl No hardcoding is needed.
  332.                 LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so"
  333.               else
  334.                 dnl Use an explicit option to hardcode DIR into the resulting
  335.                 dnl binary.
  336.                 dnl Potentially add DIR to ltrpathdirs.
  337.                 dnl The ltrpathdirs will be appended to $LTLIBNAME at the end.
  338.                 haveit=
  339.                 for x in $ltrpathdirs; do
  340.                   if test "X$x" = "X$found_dir"; then
  341.                     haveit=yes
  342.                     break
  343.                   fi
  344.                 done
  345.                 if test -z "$haveit"; then
  346.                   ltrpathdirs="$ltrpathdirs $found_dir"
  347.                 fi
  348.                 dnl The hardcoding into $LIBNAME is system dependent.
  349.                 if test "$acl_hardcode_direct" = yes; then
  350.                   dnl Using DIR/libNAME.so during linking hardcodes DIR into the
  351.                   dnl resulting binary.
  352.                   LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so"
  353.                 else
  354.                   if test -n "$acl_hardcode_libdir_flag_spec" && test "$acl_hardcode_minus_L" = no; then
  355.                     dnl Use an explicit option to hardcode DIR into the resulting
  356.                     dnl binary.
  357.                     LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so"
  358.                     dnl Potentially add DIR to rpathdirs.
  359.                     dnl The rpathdirs will be appended to $LIBNAME at the end.
  360.                     haveit=
  361.                     for x in $rpathdirs; do
  362.                       if test "X$x" = "X$found_dir"; then
  363.                         haveit=yes
  364.                         break
  365.                       fi
  366.                     done
  367.                     if test -z "$haveit"; then
  368.                       rpathdirs="$rpathdirs $found_dir"
  369.                     fi
  370.                   else
  371.                     dnl Rely on "-L$found_dir".
  372.                     dnl But don't add it if it's already contained in the LDFLAGS
  373.                     dnl or the already constructed $LIBNAME
  374.                     haveit=
  375.                     for x in $LDFLAGS $LIB[]NAME; do
  376.                       AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])
  377.                       if test "X$x" = "X-L$found_dir"; then
  378.                         haveit=yes
  379.                         break
  380.                       fi
  381.                     done
  382.                     if test -z "$haveit"; then
  383.                       LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-L$found_dir"
  384.                     fi
  385.                     if test "$acl_hardcode_minus_L" != no; then
  386.                       dnl FIXME: Not sure whether we should use
  387.                       dnl "-L$found_dir -l$name" or "-L$found_dir $found_so"
  388.                       dnl here.
  389.                       LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so"
  390.                     else
  391.                       dnl We cannot use $acl_hardcode_runpath_var and LD_RUN_PATH
  392.                       dnl here, because this doesn't fit in flags passed to the
  393.                       dnl compiler. So give up. No hardcoding. This affects only
  394.                       dnl very old systems.
  395.                       dnl FIXME: Not sure whether we should use
  396.                       dnl "-L$found_dir -l$name" or "-L$found_dir $found_so"
  397.                       dnl here.
  398.                       LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-l$name"
  399.                     fi
  400.                   fi
  401.                 fi
  402.               fi
  403.             else
  404.               if test "X$found_a" != "X"; then
  405.                 dnl Linking with a static library.
  406.                 LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_a"
  407.               else
  408.                 dnl We shouldn't come here, but anyway it's good to have a
  409.                 dnl fallback.
  410.                 LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-L$found_dir -l$name"
  411.               fi
  412.             fi
  413.             dnl Assume the include files are nearby.
  414.             additional_includedir=
  415.             case "$found_dir" in
  416.               */$acl_libdirstem | */$acl_libdirstem/)
  417.                 basedir=`echo "X$found_dir" | sed -e 's,^X,,' -e "s,/$acl_libdirstem/"'*$,,'`
  418.                 LIB[]NAME[]_PREFIX="$basedir"
  419.                 additional_includedir="$basedir/include"
  420.                 ;;
  421.             esac
  422.             if test "X$additional_includedir" != "X"; then
  423.               dnl Potentially add $additional_includedir to $INCNAME.
  424.               dnl But don't add it
  425.               dnl   1. if it's the standard /usr/include,
  426.               dnl   2. if it's /usr/local/include and we are using GCC on Linux,
  427.               dnl   3. if it's already present in $CPPFLAGS or the already
  428.               dnl      constructed $INCNAME,
  429.               dnl   4. if it doesn't exist as a directory.
  430.               if test "X$additional_includedir" != "X/usr/include"; then
  431.                 haveit=
  432.                 if test "X$additional_includedir" = "X/usr/local/include"; then
  433.                   if test -n "$GCC"; then
  434.                     case $host_os in
  435.                       linux* | gnu* | k*bsd*-gnu) haveit=yes;;
  436.                     esac
  437.                   fi
  438.                 fi
  439.                 if test -z "$haveit"; then
  440.                   for x in $CPPFLAGS $INC[]NAME; do
  441.                     AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])
  442.                     if test "X$x" = "X-I$additional_includedir"; then
  443.                       haveit=yes
  444.                       break
  445.                     fi
  446.                   done
  447.                   if test -z "$haveit"; then
  448.                     if test -d "$additional_includedir"; then
  449.                       dnl Really add $additional_includedir to $INCNAME.
  450.                       INC[]NAME="${INC[]NAME}${INC[]NAME:+ }-I$additional_includedir"
  451.                     fi
  452.                   fi
  453.                 fi
  454.               fi
  455.             fi
  456.             dnl Look for dependencies.
  457.             if test -n "$found_la"; then
  458.               dnl Read the .la file. It defines the variables
  459.               dnl dlname, library_names, old_library, dependency_libs, current,
  460.               dnl age, revision, installed, dlopen, dlpreopen, libdir.
  461.               save_libdir="$libdir"
  462.               case "$found_la" in
  463.                 */* | *\\*) . "$found_la" ;;
  464.                 *) . "./$found_la" ;;
  465.               esac
  466.               libdir="$save_libdir"
  467.               dnl We use only dependency_libs.
  468.               for dep in $dependency_libs; do
  469.                 case "$dep" in
  470.                   -L*)
  471.                     additional_libdir=`echo "X$dep" | sed -e 's/^X-L//'`
  472.                     dnl Potentially add $additional_libdir to $LIBNAME and $LTLIBNAME.
  473.                     dnl But don't add it
  474.                     dnl   1. if it's the standard /usr/lib,
  475.                     dnl   2. if it's /usr/local/lib and we are using GCC on Linux,
  476.                     dnl   3. if it's already present in $LDFLAGS or the already
  477.                     dnl      constructed $LIBNAME,
  478.                     dnl   4. if it doesn't exist as a directory.
  479.                     if test "X$additional_libdir" != "X/usr/$acl_libdirstem"; then
  480.                       haveit=
  481.                       if test "X$additional_libdir" = "X/usr/local/$acl_libdirstem"; then
  482.                         if test -n "$GCC"; then
  483.                           case $host_os in
  484.                             linux* | gnu* | k*bsd*-gnu) haveit=yes;;
  485.                           esac
  486.                         fi
  487.                       fi
  488.                       if test -z "$haveit"; then
  489.                         haveit=
  490.                         for x in $LDFLAGS $LIB[]NAME; do
  491.                           AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])
  492.                           if test "X$x" = "X-L$additional_libdir"; then
  493.                             haveit=yes
  494.                             break
  495.                           fi
  496.                         done
  497.                         if test -z "$haveit"; then
  498.                           if test -d "$additional_libdir"; then
  499.                             dnl Really add $additional_libdir to $LIBNAME.
  500.                             LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-L$additional_libdir"
  501.                           fi
  502.                         fi
  503.                         haveit=
  504.                         for x in $LDFLAGS $LTLIB[]NAME; do
  505.                           AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])
  506.                           if test "X$x" = "X-L$additional_libdir"; then
  507.                             haveit=yes
  508.                             break
  509.                           fi
  510.                         done
  511.                         if test -z "$haveit"; then
  512.                           if test -d "$additional_libdir"; then
  513.                             dnl Really add $additional_libdir to $LTLIBNAME.
  514.                             LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-L$additional_libdir"
  515.                           fi
  516.                         fi
  517.                       fi
  518.                     fi
  519.                     ;;
  520.                   -R*)
  521.                     dir=`echo "X$dep" | sed -e 's/^X-R//'`
  522.                     if test "$enable_rpath" != no; then
  523.                       dnl Potentially add DIR to rpathdirs.
  524.                       dnl The rpathdirs will be appended to $LIBNAME at the end.
  525.                       haveit=
  526.                       for x in $rpathdirs; do
  527.                         if test "X$x" = "X$dir"; then
  528.                           haveit=yes
  529.                           break
  530.                         fi
  531.                       done
  532.                       if test -z "$haveit"; then
  533.                         rpathdirs="$rpathdirs $dir"
  534.                       fi
  535.                       dnl Potentially add DIR to ltrpathdirs.
  536.                       dnl The ltrpathdirs will be appended to $LTLIBNAME at the end.
  537.                       haveit=
  538.                       for x in $ltrpathdirs; do
  539.                         if test "X$x" = "X$dir"; then
  540.                           haveit=yes
  541.                           break
  542.                         fi
  543.                       done
  544.                       if test -z "$haveit"; then
  545.                         ltrpathdirs="$ltrpathdirs $dir"
  546.                       fi
  547.                     fi
  548.                     ;;
  549.                   -l*)
  550.                     dnl Handle this in the next round.
  551.                     names_next_round="$names_next_round "`echo "X$dep" | sed -e 's/^X-l//'`
  552.                     ;;
  553.                   *.la)
  554.                     dnl Handle this in the next round. Throw away the .la's
  555.                     dnl directory; it is already contained in a preceding -L
  556.                     dnl option.
  557.                     names_next_round="$names_next_round "`echo "X$dep" | sed -e 's,^X.*/,,' -e 's,^lib,,' -e 's,\.la$,,'`
  558.                     ;;
  559.                   *)
  560.                     dnl Most likely an immediate library name.
  561.                     LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$dep"
  562.                     LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }$dep"
  563.                     ;;
  564.                 esac
  565.               done
  566.             fi
  567.           else
  568.             dnl Didn't find the library; assume it is in the system directories
  569.             dnl known to the linker and runtime loader. (All the system
  570.             dnl directories known to the linker should also be known to the
  571.             dnl runtime loader, otherwise the system is severely misconfigured.)
  572.             LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-l$name"
  573.             LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-l$name"
  574.           fi
  575.         fi
  576.       fi
  577.     done
  578.   done
  579.   if test "X$rpathdirs" != "X"; then
  580.     if test -n "$acl_hardcode_libdir_separator"; then
  581.       dnl Weird platform: only the last -rpath option counts, the user must
  582.       dnl pass all path elements in one option. We can arrange that for a
  583.       dnl single library, but not when more than one $LIBNAMEs are used.
  584.       alldirs=
  585.       for found_dir in $rpathdirs; do
  586.         alldirs="${alldirs}${alldirs:+$acl_hardcode_libdir_separator}$found_dir"
  587.       done
  588.       dnl Note: acl_hardcode_libdir_flag_spec uses $libdir and $wl.
  589.       acl_save_libdir="$libdir"
  590.       libdir="$alldirs"
  591.       eval flag=\"$acl_hardcode_libdir_flag_spec\"
  592.       libdir="$acl_save_libdir"
  593.       LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$flag"
  594.     else
  595.       dnl The -rpath options are cumulative.
  596.       for found_dir in $rpathdirs; do
  597.         acl_save_libdir="$libdir"
  598.         libdir="$found_dir"
  599.         eval flag=\"$acl_hardcode_libdir_flag_spec\"
  600.         libdir="$acl_save_libdir"
  601.         LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$flag"
  602.       done
  603.     fi
  604.   fi
  605.   if test "X$ltrpathdirs" != "X"; then
  606.     dnl When using libtool, the option that works for both libraries and
  607.     dnl executables is -R. The -R options are cumulative.
  608.     for found_dir in $ltrpathdirs; do
  609.       LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-R$found_dir"
  610.     done
  611.   fi
  612. ])
  613.  
  614. dnl AC_LIB_APPENDTOVAR(VAR, CONTENTS) appends the elements of CONTENTS to VAR,
  615. dnl unless already present in VAR.
  616. dnl Works only for CPPFLAGS, not for LIB* variables because that sometimes
  617. dnl contains two or three consecutive elements that belong together.
  618. AC_DEFUN([AC_LIB_APPENDTOVAR],
  619. [
  620.   for element in [$2]; do
  621.     haveit=
  622.     for x in $[$1]; do
  623.       AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])
  624.       if test "X$x" = "X$element"; then
  625.         haveit=yes
  626.         break
  627.       fi
  628.     done
  629.     if test -z "$haveit"; then
  630.       [$1]="${[$1]}${[$1]:+ }$element"
  631.     fi
  632.   done
  633. ])
  634.  
  635. dnl For those cases where a variable contains several -L and -l options
  636. dnl referring to unknown libraries and directories, this macro determines the
  637. dnl necessary additional linker options for the runtime path.
  638. dnl AC_LIB_LINKFLAGS_FROM_LIBS([LDADDVAR], [LIBSVALUE], [USE-LIBTOOL])
  639. dnl sets LDADDVAR to linker options needed together with LIBSVALUE.
  640. dnl If USE-LIBTOOL evaluates to non-empty, linking with libtool is assumed,
  641. dnl otherwise linking without libtool is assumed.
  642. AC_DEFUN([AC_LIB_LINKFLAGS_FROM_LIBS],
  643. [
  644.   AC_REQUIRE([AC_LIB_RPATH])
  645.   AC_REQUIRE([AC_LIB_PREPARE_MULTILIB])
  646.   $1=
  647.   if test "$enable_rpath" != no; then
  648.     if test -n "$acl_hardcode_libdir_flag_spec" && test "$acl_hardcode_minus_L" = no; then
  649.       dnl Use an explicit option to hardcode directories into the resulting
  650.       dnl binary.
  651.       rpathdirs=
  652.       next=
  653.       for opt in $2; do
  654.         if test -n "$next"; then
  655.           dir="$next"
  656.           dnl No need to hardcode the standard /usr/lib.
  657.           if test "X$dir" != "X/usr/$acl_libdirstem"; then
  658.             rpathdirs="$rpathdirs $dir"
  659.           fi
  660.           next=
  661.         else
  662.           case $opt in
  663.             -L) next=yes ;;
  664.             -L*) dir=`echo "X$opt" | sed -e 's,^X-L,,'`
  665.                  dnl No need to hardcode the standard /usr/lib.
  666.                  if test "X$dir" != "X/usr/$acl_libdirstem"; then
  667.                    rpathdirs="$rpathdirs $dir"
  668.                  fi
  669.                  next= ;;
  670.             *) next= ;;
  671.           esac
  672.         fi
  673.       done
  674.       if test "X$rpathdirs" != "X"; then
  675.         if test -n ""$3""; then
  676.           dnl libtool is used for linking. Use -R options.
  677.           for dir in $rpathdirs; do
  678.             $1="${$1}${$1:+ }-R$dir"
  679.           done
  680.         else
  681.           dnl The linker is used for linking directly.
  682.           if test -n "$acl_hardcode_libdir_separator"; then
  683.             dnl Weird platform: only the last -rpath option counts, the user
  684.             dnl must pass all path elements in one option.
  685.             alldirs=
  686.             for dir in $rpathdirs; do
  687.               alldirs="${alldirs}${alldirs:+$acl_hardcode_libdir_separator}$dir"
  688.             done
  689.             acl_save_libdir="$libdir"
  690.             libdir="$alldirs"
  691.             eval flag=\"$acl_hardcode_libdir_flag_spec\"
  692.             libdir="$acl_save_libdir"
  693.             $1="$flag"
  694.           else
  695.             dnl The -rpath options are cumulative.
  696.             for dir in $rpathdirs; do
  697.               acl_save_libdir="$libdir"
  698.               libdir="$dir"
  699.               eval flag=\"$acl_hardcode_libdir_flag_spec\"
  700.               libdir="$acl_save_libdir"
  701.               $1="${$1}${$1:+ }$flag"
  702.             done
  703.           fi
  704.         fi
  705.       fi
  706.     fi
  707.   fi
  708.   AC_SUBST([$1])
  709. ])
  710.